// c16_char_escape - 转义字符：特殊字符的表示方法
// 《Rust基础数据类型实战Cookbook》案例16

fn main() {
    println!("=== Rust 转义字符详解 ===\n");

    // 1. 基本转义字符概述
    basic_escape_overview();

    // 2. 常用转义序列演示
    common_escape_sequences();

    // 3. ASCII 转义序列
    ascii_escape_sequences();

    // 4. Unicode 转义序列
    unicode_escape_sequences();

    // 5. 控制字符转义
    control_character_escapes();

    // 6. 特殊符号转义
    special_symbol_escapes();

    // 7. 转义字符在字符串中的应用
    escape_in_strings();

    // 8. 原始字符串与转义字符对比
    raw_strings_vs_escapes();

    // 9. 实际应用场景演示
    practical_applications();

    println!("\n=== 转义字符学习完成 ===");
}

/// 1. 基本转义字符概述
/// 介绍什么是转义字符以及为什么需要转义字符
fn basic_escape_overview() {
    println!("1. 转义字符概述");
    println!("   转义字符是用反斜杠(\\)开头的字符序列，用来表示难以直接输入的特殊字符");
    println!("   在 Rust 中，转义字符可以用于字符字面量和字符串字面量中\n");

    // 转义字符的基本概念
    let newline_char = '\n';           // 换行字符
    let tab_char = '\t';               // 制表符字符
    let backslash_char = '\\';         // 反斜杠字符
    let quote_char = '\'';             // 单引号字符

    println!("1.1 基本概念展示");
    println!("   换行字符: {:?} (Unicode: U+{:04X})", newline_char, newline_char as u32);
    println!("   制表符: {:?} (Unicode: U+{:04X})", tab_char, tab_char as u32);
    println!("   反斜杠: {:?} (Unicode: U+{:04X})", backslash_char, backslash_char as u32);
    println!("   单引号: {:?} (Unicode: U+{:04X})", quote_char, quote_char as u32);

    // 为什么需要转义字符
    println!("\n1.2 为什么需要转义字符？");
    println!("   • 表示不可见的控制字符（如换行、制表符）");
    println!("   • 表示在语法中有特殊意义的字符（如引号、反斜杠）");
    println!("   • 表示键盘上难以输入的字符");
    println!("   • 统一表示各种特殊字符，增强代码可读性");
    println!();
}

/// 2. 常用转义序列演示
/// 展示 Rust 中最常用的转义序列
fn common_escape_sequences() {
    println!("2. 常用转义序列");
    println!("   以下是 Rust 中最常用的转义序列：\n");

    // 常用转义序列表格式展示
    println!("2.1 基础转义序列表");
    println!("   ┌────────────┬─────────────┬───────────────────┬──────────────┐");
    println!("   │ 转义序列   │ 字符描述    │ Unicode码点       │ 实际效果     │");
    println!("   ├────────────┼─────────────┼───────────────────┼──────────────┤");

    let escape_chars = [
        ("\\n", "换行符", '\n'),
        ("\\t", "水平制表符", '\t'),
        ("\\r", "回车符", '\r'),
        ("\\\\", "反斜杠", '\\'),
        ("\\'", "单引号", '\''),
        ("\\\"", "双引号", '"'),
        ("\\0", "空字符", '\0'),
    ];

    for (escape_seq, description, actual_char) in &escape_chars {
        println!("   │ {:10} │ {:11} │ U+{:04X}            │ {:?}          │", 
                 escape_seq, description, *actual_char as u32, actual_char);
    }
    println!("   └────────────┴─────────────┴───────────────────┴──────────────┘\n");

    // 实际演示这些转义字符的效果
    println!("2.2 转义字符效果演示");
    println!("换行符演示：");
    println!("第一行\\n第二行");  // 这里会换行
    
    println!("\n制表符演示：");
    println!("列1\t列2\t列3");
    println!("A\tB\tC");
    
    println!("\n引号转义演示：");
    println!("单引号: 'It\\'s a beautiful day!'");
    println!("双引号: \"He said, \\\"Hello, world!\\\"\"");
    println!();
}

/// 3. ASCII 转义序列
/// 展示使用十六进制表示 ASCII 字符的转义序列
fn ascii_escape_sequences() {
    println!("3. ASCII 转义序列");
    println!("   使用 \\x 后跟两位十六进制数字表示 ASCII 字符（0x00-0x7F）\n");

    println!("3.1 ASCII 转义序列基本语法");
    println!("   格式：\\xHH  (H 表示十六进制数字 0-9, A-F)");
    println!("   范围：\\x00 到 \\x7F (对应 ASCII 0-127)\n");

    // ASCII 字符示例
    let ascii_chars = [
        ("\\x20", 0x20, "空格"),
        ("\\x21", 0x21, "感叹号 !"),
        ("\\x41", 0x41, "大写字母 A"),
        ("\\x61", 0x61, "小写字母 a"),
        ("\\x30", 0x30, "数字 0"),
        ("\\x0A", 0x0A, "换行符"),
        ("\\x09", 0x09, "制表符"),
        ("\\x7F", 0x7F, "DEL 删除字符"),
    ];

    println!("3.2 ASCII 转义序列示例");
    println!("   ┌────────────┬──────────┬─────────────────┬─────────────┐");
    println!("   │ 转义序列   │ 十进制   │ 字符描述        │ 实际字符    │");
    println!("   ├────────────┼──────────┼─────────────────┼─────────────┤");

    for (escape_seq, hex_value, description, ) in &ascii_chars {
        let actual_char = char::from(*hex_value);
        let display_char = if actual_char.is_control() {
            format!("[控制字符]")
        } else {
            format!("'{}'", actual_char)
        };
        
        println!("   │ {:10} │ {:8} │ {:15} │ {:11} │", 
                 escape_seq, *hex_value, description, display_char);
    }
    println!("   └────────────┴──────────┴─────────────────┴─────────────┘\n");

    // 实际使用 ASCII 转义序列
    println!("3.3 实际使用演示");
    let space = '\x20';          // 空格字符
    let exclamation = '\x21';    // 感叹号
    let letter_a = '\x41';       // 字母 A
    let digit_zero = '\x30';     // 数字 0
    
    println!("使用 ASCII 转义构建字符串:");
    print!("{}{}{}{}{}{}{}",     // 不换行打印
           letter_a,             // A
           space,                // 空格
           digit_zero,           // 0
           space,                // 空格
           exclamation,          // !
           '\x0A',               // 换行符
           '\x09');              // 制表符开头
    println!("ASCII 转义序列演示完成");
    println!();
}

/// 4. Unicode 转义序列
/// 展示使用 Unicode 码点表示字符的转义序列
fn unicode_escape_sequences() {
    println!("4. Unicode 转义序列");
    println!("   使用 \\u{{...}} 格式表示任意 Unicode 字符\n");

    println!("4.1 Unicode 转义语法");
    println!("   格式：\\u{{XXXXXX}}  (X 表示十六进制数字，1-6位)");
    println!("   范围：\\u{{0}} 到 \\u{{10FFFF}} (整个 Unicode 范围)");
    println!("   优势：可以表示所有 Unicode 字符，包括非 ASCII 字符\n");

    // Unicode 字符示例
    println!("4.2 Unicode 转义序列示例");
    println!("   ┌─────────────────┬──────────┬─────────────────┬─────────────┐");
    println!("   │ 转义序列        │ 码点     │ 字符描述        │ 实际字符    │");
    println!("   ├─────────────────┼──────────┼─────────────────┼─────────────┤");

    let unicode_examples = [
        ("\\u{41}", 0x41, "拉丁字母 A", '\u{41}'),
        ("\\u{4E2D}", 0x4E2D, "中文：中", '\u{4E2D}'),
        ("\\u{65E5}", 0x65E5, "日文：日", '\u{65E5}'),
        ("\\u{D55C}", 0xD55C, "韩文：한", '\u{D55C}'),
        ("\\u{1F600}", 0x1F600, "笑脸表情", '\u{1F600}'),
        ("\\u{1F680}", 0x1F680, "火箭表情", '\u{1F680}'),
        ("\\u{03B1}", 0x03B1, "希腊字母 α", '\u{03B1}'),
        ("\\u{20AC}", 0x20AC, "欧元符号", '\u{20AC}'),
    ];

    for (escape_seq, code_point, description, actual_char) in &unicode_examples {
        println!("   │ {:15} │ U+{:04X}   │ {:15} │ {:11} │", 
                 escape_seq, code_point, description, actual_char);
    }
    println!("   └─────────────────┴──────────┴─────────────────┴─────────────┘\n");

    // Unicode 平面演示
    println!("4.3 不同 Unicode 平面的字符");
    println!("基本多文种平面 (BMP, U+0000-U+FFFF):");
    println!("   英文: {} (U+{:04X})", '\u{41}', '\u{41}' as u32);
    println!("   中文: {} (U+{:04X})", '\u{4E2D}', '\u{4E2D}' as u32);
    println!("   符号: {} (U+{:04X})", '\u{2603}', '\u{2603}' as u32);
    
    println!("\n增补平面 (U+10000-U+10FFFF):");
    println!("   表情: {} (U+{:X})", '\u{1F600}', '\u{1F600}' as u32);
    println!("   音符: {} (U+{:X})", '\u{1D11E}', '\u{1D11E}' as u32);

    // 实际应用示例
    println!("\n4.4 实际应用示例");
    let greeting = "你好\u{FF0C}世界\u{FF01}";  // 使用全角逗号和感叹号
    println!("多语言字符串: {}", greeting);
    
    let math_formula = "α² + β² = γ²";  // 使用希腊字母
    println!("数学公式: {}", math_formula);
    
    let emoji_string = "今天天气很好 \u{2600}\u{FE0F}";  // 太阳表情
    println!("表情字符串: {}", emoji_string);
    println!();
}

/// 5. 控制字符转义
/// 展示各种控制字符的转义表示
fn control_character_escapes() {
    println!("5. 控制字符转义");
    println!("   控制字符是不可打印的字符，用于控制文本显示和设备行为\n");

    // 控制字符分类
    println!("5.1 常见控制字符");
    println!("   ┌────────────┬───────────────┬──────────┬─────────────────────┐");
    println!("   │ 转义序列   │ 字符名称      │ ASCII值  │ 功能描述            │");
    println!("   ├────────────┼───────────────┼──────────┼─────────────────────┤");

    let control_chars = [
        ("\\0", "NUL", 0, "空字符，字符串结束标记"),
        ("\\t", "TAB", 9, "水平制表符，对齐文本"),
        ("\\n", "LF", 10, "换行符，移到下一行"),
        ("\\r", "CR", 13, "回车符，移到行首"),
        ("\\x07", "BEL", 7, "响铃字符，发出警告音"),
        ("\\x08", "BS", 8, "退格符，删除前一字符"),
        ("\\x0C", "FF", 12, "换页符，打印机换页"),
        ("\\x1B", "ESC", 27, "转义符，ANSI序列开始"),
    ];

    for (escape_seq, name, ascii_val, description) in &control_chars {
        println!("   │ {:10} │ {:13} │ {:8} │ {:19} │", 
                 escape_seq, name, ascii_val, description);
    }
    println!("   └────────────┴───────────────┴──────────┴─────────────────────┘\n");

    // 控制字符效果演示
    println!("5.2 控制字符效果演示");
    
    // 制表符对齐演示
    println!("制表符对齐效果：");
    println!("姓名\t年龄\t城市");
    println!("张三\t25\t北京");
    println!("李四\t30\t上海");
    println!("王五\t28\t深圳");
    
    // 不同换行符组合
    println!("\n换行符组合：");
    print!("Unix风格换行:\\n");
    print!("第二行内容\n");
    
    print!("Windows风格换行:\\r\\n");
    print!("第二行内容\r\n");
    
    // 空字符演示
    println!("空字符演示：");
    let null_terminated = "Hello\0World";
    println!("字符串内容: {:?}", null_terminated);
    println!("字符串长度: {}", null_terminated.len());
    
    // 退格符效果（在终端中可能不可见）
    println!("\n退格符概念演示：");
    println!("原始: ABC\\x08D  (理论上显示为: ABD，C被退格删除)");
    println!();
}

/// 6. 特殊符号转义
/// 展示在语法中有特殊意义的符号如何转义
fn special_symbol_escapes() {
    println!("6. 特殊符号转义");
    println!("   在 Rust 中，某些字符在语法中有特殊意义，需要转义来表示字面意思\n");

    println!("6.1 语法特殊字符");
    println!("   ┌────────────┬─────────────────┬─────────────────────────┐");
    println!("   │ 原字符     │ 转义后          │ 使用场景                │");
    println!("   ├────────────┼─────────────────┼─────────────────────────┤");
    println!("   │ \\          │ \\\\             │ 文件路径、正则表达式    │");
    println!("   │ '          │ \\'              │ 字符字面量中的单引号    │");
    println!("   │ \"          │ \\\"             │ 字符串字面量中的双引号  │");
    println!("   └────────────┴─────────────────┴─────────────────────────┘\n");

    // 反斜杠转义示例
    println!("6.2 反斜杠转义示例");
    let file_path = "C:\\Users\\Administrator\\Documents";
    println!("Windows 文件路径: \"{}\"", file_path);
    
    let regex_pattern = "\\d+\\.\\d+";  // 匹配小数的正则表达式
    println!("正则表达式模式: \"{}\"", regex_pattern);
    
    let escaped_backslash = '\\';
    println!("反斜杠字符: '{}'", escaped_backslash);

    // 引号转义示例
    println!("\n6.3 引号转义示例");
    
    // 单引号在字符中的转义
    let single_quote_char = '\'';
    println!("单引号字符: {:?}", single_quote_char);
    
    // 双引号在字符串中的转义
    let quoted_text = "他说：\"你好，世界！\"";
    println!("包含双引号的字符串: {}", quoted_text);
    
    // 混合引号的复杂示例
    let complex_quote = "She said: 'I can\\'t believe he said \"Hello!\"'";
    println!("复杂引号嵌套: {}", complex_quote);

    // JSON 字符串示例
    println!("\n6.4 实际应用：JSON 字符串");
    let json_like = "{\"name\": \"张三\", \"message\": \"他说：\\\"你好！\\\"\"}";
    println!("JSON格式字符串: {}", json_like);

    // SQL 查询示例
    println!("\n6.5 实际应用：SQL 查询字符串");
    let sql_query = "SELECT * FROM users WHERE name = 'O\\'Reilly'";
    println!("SQL查询字符串: {}", sql_query);
    println!();
}

/// 7. 转义字符在字符串中的应用
/// 展示转义字符在不同类型字符串中的使用
fn escape_in_strings() {
    println!("7. 转义字符在字符串中的应用");
    println!("   转义字符不仅可以用于字符字面量，更常用于字符串字面量中\n");

    // 多行字符串使用转义字符
    println!("7.1 多行字符串格式化");
    let formatted_text = "第一行\n第二行\n\t缩进的第三行\n第四行";
    println!("使用转义字符的多行文本:");
    println!("{}", formatted_text);
    
    // 表格格式化
    println!("\n7.2 表格格式化");
    let table = "产品名称\t价格\t库存\n苹果\t\t3.50\t100\n香蕉\t\t2.80\t150\n橙子\t\t4.20\t80";
    println!("商品清单表格:");
    println!("{}", table);

    // HTML/XML 标签示例
    println!("\n7.3 HTML/XML 内容");
    let html_content = "<p>这是一个段落</p>\n<div>\n\t<span>嵌套内容</span>\n</div>";
    println!("HTML 结构:");
    println!("{}", html_content);

    // 配置文件格式
    println!("\n7.4 配置文件格式");
    let config_content = "[database]\nhost=localhost\nport=5432\nname=\"my_app\"\n\n[server]\naddress=\"0.0.0.0\"\nport=8080";
    println!("配置文件内容:");
    println!("{}", config_content);

    // CSV 格式数据
    println!("\n7.5 CSV 格式数据");
    let csv_data = "姓名,年龄,城市\n\"张,三\",25,\"北京\"\n\"李四\",30,\"上,海\"\n\"王五\",28,深圳";
    println!("CSV 数据格式:");
    println!("{}", csv_data);

    // 日志格式
    println!("\n7.6 日志格式");
    let log_entry = "[2024-01-15 10:30:45] INFO: 用户登录成功\n[2024-01-15 10:31:12] ERROR: 数据库连接失败\n\t错误详情: 连接超时";
    println!("应用程序日志:");
    println!("{}", log_entry);
    println!();
}

/// 8. 原始字符串与转义字符对比
/// 对比原始字符串和包含转义字符的字符串
fn raw_strings_vs_escapes() {
    println!("8. 原始字符串与转义字符对比");
    println!("   原始字符串使用 r\"...\" 语法，不处理转义字符，按字面意思处理所有字符\n");

    // 基本对比
    println!("8.1 基本语法对比");
    let normal_string = "Hello\\nWorld\\t!";
    let raw_string = r"Hello\nWorld\t!";
    
    println!("普通字符串: \"{}\"", normal_string);
    println!("显示效果: {}", normal_string);
    println!("原始字符串: r\"{}\"", raw_string);
    println!("显示效果: {}", raw_string);

    // 文件路径对比
    println!("\n8.2 文件路径处理对比");
    let escaped_path = "C:\\Users\\Documents\\file.txt";
    let raw_path = r"C:\Users\Documents\file.txt";
    
    println!("转义方式: \"{}\"", escaped_path);
    println!("原始字符串: r\"{}\"", raw_path);
    println!("两者是否相等: {}", escaped_path == raw_path);

    // 正则表达式对比
    println!("\n8.3 正则表达式模式对比");
    let escaped_regex = "\\d{4}-\\d{2}-\\d{2}";      // 日期格式
    let raw_regex = r"\d{4}-\d{2}-\d{2}";
    
    println!("转义方式: \"{}\"", escaped_regex);
    println!("原始字符串: r\"{}\"", raw_regex);
    println!("两者是否相等: {}", escaped_regex == raw_regex);

    // JSON 字符串对比
    println!("\n8.4 JSON 字符串对比");
    let escaped_json = "{\"name\": \"张三\", \"age\": 25}";
    let raw_json = r#"{"name": "张三", "age": 25}"#;  // 使用 r#"..."# 语法处理包含双引号的原始字符串
    
    println!("转义方式: \"{}\"", escaped_json);
    println!("原始字符串: r#\"{}\"#", raw_json);
    println!("两者是否相等: {}", escaped_json == raw_json);

    // SQL 查询对比
    println!("\n8.5 SQL 查询字符串对比");
    let escaped_sql = "SELECT * FROM users WHERE name = 'O\\'Reilly' AND path LIKE 'C:\\\\%'";
    let raw_sql = r"SELECT * FROM users WHERE name = 'O\'Reilly' AND path LIKE 'C:\%'";
    
    println!("转义方式: \"{}\"", escaped_sql);
    println!("原始字符串: r\"{}\"", raw_sql);

    // 使用场景建议
    println!("\n8.6 使用场景建议");
    println!("┌─────────────────────┬─────────────────────┐");
    println!("│ 转义字符串          │ 原始字符串          │");
    println!("├─────────────────────┼─────────────────────┤");
    println!("│ • 需要换行、制表符  │ • 文件路径          │");
    println!("│ • 需要控制字符      │ • 正则表达式        │");
    println!("│ • 简单文本格式化    │ • Windows路径       │");
    println!("│ • 包含少量转义      │ • 包含大量反斜杠    │");
    println!("└─────────────────────┴─────────────────────┘");
    println!();
}

/// 9. 实际应用场景演示
/// 展示转义字符在真实编程场景中的应用
fn practical_applications() {
    println!("9. 实际应用场景演示");
    println!("   以下是转义字符在实际编程中的常见应用场景\n");

    // 9.1 文本格式化和报告生成
    println!("9.1 报告生成示例");
    generate_report();

    // 9.2 配置文件处理
    println!("\n9.2 配置文件内容生成");
    generate_config_file();

    // 9.3 日志记录
    println!("\n9.3 日志记录功能");
    demonstrate_logging();

    // 9.4 数据交换格式
    println!("\n9.4 数据交换格式（JSON/CSV）");
    demonstrate_data_formats();

    // 9.5 用户界面文本
    println!("\n9.5 用户界面消息");
    demonstrate_ui_messages();

    // 9.6 文件路径处理
    println!("\n9.6 跨平台路径处理");
    demonstrate_path_handling();
}

/// 生成格式化报告
fn generate_report() {
    let report = format!(
        "=== 销售报告 ===\n\
         日期：{}\n\
         \n\
         产品销售情况：\n\
         \t苹果\t\t销量：100\t营收：￥350.00\n\
         \t香蕉\t\t销量：150\t营收：￥420.00\n\
         \t橙子\t\t销量：80\t\t营收：￥336.00\n\
         \n\
         总计：\t\t销量：330\t营收：￥1,106.00\n\
         \n\
         备注：本报告由系统自动生成",
        "2024-01-15"
    );
    
    println!("{}", report);
}

/// 生成配置文件内容
fn generate_config_file() {
    let config = "[database]\n\
                 host = \"localhost\"\n\
                 port = 5432\n\
                 username = \"admin\"\n\
                 password = \"secret123!\"\n\
                 \n\
                 [server]\n\
                 bind_address = \"0.0.0.0:8080\"\n\
                 max_connections = 100\n\
                 timeout = 30\n\
                 \n\
                 [logging]\n\
                 level = \"info\"\n\
                 file = \"/var/log/app.log\"";
    
    println!("生成的配置文件内容：");
    println!("{}", config);
}

/// 演示日志记录功能
fn demonstrate_logging() {
    let log_entries = vec![
        "[2024-01-15 10:30:45] INFO: 用户登录成功 - UserID: 12345",
        "[2024-01-15 10:31:12] ERROR: 数据库连接失败\n\t错误码: 1045\n\t错误信息: Access denied",
        "[2024-01-15 10:31:30] WARN: 内存使用率过高: 85%\n\t建议操作: 清理缓存",
        "[2024-01-15 10:32:00] DEBUG: API调用详情\n\t请求地址: /api/users\n\t响应时间: 125ms",
    ];
    
    println!("日志系统输出：");
    for entry in log_entries {
        println!("{}", entry);
    }
}

/// 演示数据交换格式
fn demonstrate_data_formats() {
    // JSON 格式示例
    println!("JSON 数据格式：");
    let json_data = "{\n\t\"users\": [\n\t\t{\n\t\t\t\"name\": \"张三\",\n\t\t\t\"email\": \"zhangsan@example.com\",\n\t\t\t\"status\": \"active\"\n\t\t},\n\t\t{\n\t\t\t\"name\": \"李四\",\n\t\t\t\"email\": \"lisi@example.com\",\n\t\t\t\"status\": \"inactive\"\n\t\t}\n\t]\n}";
    println!("{}", json_data);
    
    // CSV 格式示例
    println!("\nCSV 数据格式：");
    let csv_data = "订单ID,客户姓名,产品名称,数量,金额\n\"ORD-001\",\"张三\",\"MacBook Pro\",1,\"¥12,999.00\"\n\"ORD-002\",\"李四\",\"iPhone 15\",2,\"¥11,998.00\"\n\"ORD-003\",\"王五\",\"iPad Air\",1,\"¥4,599.00\"";
    println!("{}", csv_data);
}

/// 演示用户界面消息
fn demonstrate_ui_messages() {
    // 错误消息
    let error_msg = "❌ 错误：用户名或密码不正确！\n\n请检查以下内容：\n\t• 用户名是否输入正确\n\t• 密码是否区分大小写\n\t• 账户是否已被锁定\n\n如需帮助，请联系技术支持：support@example.com";
    println!("错误提示消息：");
    println!("{}", error_msg);
    
    // 成功消息
    println!("\n成功提示消息：");
    let success_msg = "✅ 恭喜！注册成功！\n\n账户信息：\n\t用户名：新用户123\n\t注册时间：2024-01-15 19:25:00\n\t账户状态：已激活\n\n💌 激活邮件已发送至您的邮箱，请查收。";
    println!("{}", success_msg);
    
    // 警告消息
    println!("\n警告提示消息：");
    let warning_msg = "⚠️  注意：您的账户将在 3 天后过期！\n\n到期时间：2024-01-18 23:59:59\n建议操作：\n\t1. 立即续费以继续使用服务\n\t2. 备份重要数据\n\t3. 联系客服了解续费优惠";
    println!("{}", warning_msg);
}

/// 演示跨平台路径处理
fn demonstrate_path_handling() {
    // Windows 路径
    println!("Windows 风格路径：");
    let windows_path = "C:\\Program Files\\MyApp\\config\\settings.ini";
    println!("应用配置路径: {}", windows_path);
    
    // Unix/Linux 路径
    println!("\nUnix/Linux 风格路径：");
    let unix_path = "/usr/local/bin/myapp";
    let unix_config = "/home/user/.config/myapp/settings.conf";
    println!("可执行文件路径: {}", unix_path);
    println!("配置文件路径: {}", unix_config);
    
    // 相对路径
    println!("\n相对路径示例：");
    let relative_paths = vec![
        ".\\data\\input.txt",        // Windows 当前目录
        "..\\..\\backup\\data.bak",  // Windows 上级目录
        "./logs/app.log",            // Unix 当前目录
        "../resources/config.json", // Unix 上级目录
    ];
    
    for path in relative_paths {
        println!("  {}", path);
    }
    
    // 网络路径
    println!("\n网络路径示例：");
    let network_paths = vec![
        "\\\\server\\share\\documents\\report.docx",  // UNC 路径
        "ftp://files.example.com/uploads/data.csv",   // FTP 路径
        "https://api.example.com/v1/users",           // HTTP 路径
    ];
    
    for path in network_paths {
        println!("  {}", path);
    }
}
